﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Migracion.Data;
using Migracion.Data.PeOnline;
using System.Diagnostics;
using System.Xml.Linq;
using System.IO;
using Migracion.Data.Tagging;
using System.Text.RegularExpressions;
using System.Web;
using Migracion.Process.voz;
using Migracion.Data.ArbolVoces;
using System.Data.SqlClient;
using System.Data.Common;
using System.Configuration;
using Migracion.Data.Siclan;
using System.Xml;
using System.Globalization;

namespace Migracion.Process
{
    public class LegislacionProc : BaseProcess
    {
        public const string StrEstadoConTexto = "Con texto";
        public const string StrEstadoSinTexto = "Sin texto";
        public const string StrBaseOrigen = "MIGRACION_ABELEDO";
        public const string StrPais = "Argentina AP";

        public string OutputPath { get; set; }

        public bool ProcesarTextoCompleto { get; set; }

        public string AbeledoId { get; set; }

        public string SQLText { get; set; }

        private bool cancelaProceso = false;
        private object cancelaProcesoLock = false;

        public bool CancelarProceso
        {
            get
            {
                lock (cancelaProcesoLock)
                {
                    return cancelaProceso;
                }
            }
            set
            {
                lock (cancelaProcesoLock)
                {
                    cancelaProceso = value;
                }
            }
        }

        public void DoProcess()
        {
            DoProcessLegislacion();
        }

        protected void DoProcessLegislacion()
        {
            int imax = 0;

            try
            {
                watch.Start();
                LogStatusMessage("Inicio de Generación de XMLs de Legislacion", MigracionLogStatus.Information);
                InicializarManagers();
                List<int> Ids = new List<int>();
                using (PE_ONLINE_PRODUCCIONEntities ctxPeOnline = new PE_ONLINE_PRODUCCIONEntities())
                {
                    // Leer los datos
                    Ids = ObtenerIdsAProcesarLegislacion(ctxPeOnline);

                    if (Ids.Count == 0)
                    {
                        LogStatusMessage("No se encontraron normas para procesar", MigracionLogStatus.Information);
                    }
                }

                // Por cada dato,
                imax = Ids.Count;
                bool cancelar = false;
                cantidadDeFallosOk = 0;
                for (int i = 0; i < imax && !cancelar; i++)
                {
                    int idLegis = Ids[i];

                    currentId = idLegis.ToString();
                    if (CancelarProceso)
                    {
                        cancelar = true;
                    }
                    else
                    {
                        if (i % 5000 == 0)
                        {
                            GC.Collect();
                        }

                        // generar el XML
                        try
                        {
                            GenerarXMLegislacion(idLegis);
                            cantidadDeFallosOk++;
                            LogStatusMessage("Norma Procesada: " + idLegis.ToString(), MigracionLogStatus.Information);
                        }
                        catch (Exception exIndividual)
                        {
                            LogStatusMessage("Error excepción en el documento " + GetExceptionMessage(exIndividual) + GetExceptionStackTrace(exIndividual), MigracionLogStatus.Error);
                        }

                        ProgressStatus(i + 1, imax);
                    }
                }
            }
            catch (Exception ex)
            {
                LogStatusMessage("Ha ocurrido una excepción: " + GetExceptionMessage(ex) + GetExceptionStackTrace(ex), MigracionLogStatus.Error);
            }
            finally
            {
                if (CancelarProceso)
                {
                    LogStatusMessage("Proceso Cancelado", MigracionLogStatus.Information);
                }
                else
                {
                    LogStatusMessage(string.Format("Proceso Finalizado, procesados ok {0} de {1}", cantidadDeFallosOk, imax), MigracionLogStatus.Information);
                }

                watch.Stop();
            }
        }

        private List<int> ObtenerIdsAProcesarLegislacion(PE_ONLINE_PRODUCCIONEntities ctxPeOnline)
        {
            List<int> ids = new List<int>();
            if (!String.IsNullOrEmpty(SQLText))
            {
                string constr = ConfigurationManager.ConnectionStrings["PE_ONLINE_PRODUCCIONSelect"].ConnectionString;
                using (DbConnection connection = new SqlConnection(constr))
                {
                    try
                    {
                        connection.Open();
                        DbCommand command = connection.CreateCommand();
                        command.CommandText = this.SQLText;
                        command.CommandType = System.Data.CommandType.Text;

                        using (DbDataReader reader = command.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                ids.Add(reader.GetInt32(0));
                            }

                            reader.Close();
                        }
                    }
                    finally
                    {
                        connection.Close();
                    }
                }
            }
            else
            {
                if (!String.IsNullOrEmpty(AbeledoId))
                {
                    int? idFallo = (from jf in ctxPeOnline.tLegislacion
                                    join il in ctxPeOnline.tIdentLexis on jf.idIdentLexis equals il.Id
                                    where il.IdentLexis == AbeledoId
                                    && jf.idIdentLexis.HasValue
                                    select jf.idIdentLexis.Value).SingleOrDefault();

                    if (idFallo.HasValue && idFallo.Value != default(int))
                    {
                        ids.Add(idFallo.Value);
                    }
                }
                else
                {
                    ids.AddRange((from jf in ctxPeOnline.tLegislacion
                                  join il in ctxPeOnline.tIdentLexis on jf.idIdentLexis equals il.Id
                                  where jf.idIdentLexis.HasValue
                                  select jf.idIdentLexis.Value).ToList());
                }
            }

            return ids;
        }


        private void GenerarXMLegislacion(int idIdentLexis)
        {

            //La funcion para converir un cun de SICLAN a identlexis es dbo.FcunToIdentlexis(modificada_cun), lo podes ver en el spCheckUltimasModificaciones del PE_ONLINE_PRODUCCION

            using (PE_ONLINE_PRODUCCIONEntities ctxPeOnline = new PE_ONLINE_PRODUCCIONEntities())
            {

                tLegislacion legislacion = ctxPeOnline.tLegislacion.Where(l => l.idIdentLexis.HasValue && l.idIdentLexis.Value == idIdentLexis).SingleOrDefault();

                List<tLegislacionPartes> partesDeLegislacion = new List<tLegislacionPartes>();

                if (legislacion == null)
                {
                    MigraDocLog migraDocLogEntryEx = new MigraDocLog();
                    migraDocLogEntryEx.NombreArchivoGenerado = idIdentLexis.ToString();
                    migraDocLogEntryEx.ApNombreTabla = IdentityTranslationManager.tLegislacion;
                    migraDocLogEntryEx.Excepcion = true;
                    migraDocLogEntryEx.Mensaje = "No se encontró la Legislacion";
                    ctxPeOnline.MigraDocLog.AddObject(migraDocLogEntryEx);
                    ctxPeOnline.SaveChanges();
                    LogStatusMessage("No se encontró la Legislacion", MigracionLogStatus.Error);
                }
                else
                {
                    partesDeLegislacion = ctxPeOnline.tLegislacionPartes.Where(c => c.id_legislacion == legislacion.id_legislacion).ToList();
                    //// Fix por desfasaje de bases
                    //List<int> idsDeLaNorma = (from legis in ctxPeOnline.tLegislacion
                    //                          where legis.arch_fisico == legislacion.arch_fisico
                    //                          orderby legis.id_legislacion descending
                    //                          select legis.id_legislacion).ToList();

                    //int idNorma = IdTranslationManager.GetApIntFromList(IdentityTranslationManager.tLegislacion, idsDeLaNorma);
                    //if (idNorma != 0)
                    //{
                    //    // Se usó, tengo que fixear la norma para que use este id en las relaciones
                    //    legislacion.FixedId_Legislacion = idNorma;
                    //}
                    //else
                    //{
                    //    // Si no se usó, uso la norma tal cual está
                    //    legislacion.FixedId_Legislacion = legislacion.id_legislacion;
                    //}

                    string nombreDocumento = idIdentLexis.ToString() + ".xml";
                    MigraDocLog migraDocLogEntry = new MigraDocLog();
                    migraDocLogEntry.NombreArchivoGenerado = nombreDocumento;
                    migraDocLogEntry.ApNombreTabla = IdentityTranslationManager.tLegislacion;
                    migraDocLogEntry.Excepcion = false;
                    migraDocLogEntry.Mensaje = string.Empty;

                    try
                    {
                        XDocument legisDocument = new XDocument();
                        XElement documentoElement = new XElement("legislacion-consolidada");
                        legisDocument.Add(documentoElement);
                        XElement metaDocumentoElement = new XElement("meta-legislacion");
                        documentoElement.Add(metaDocumentoElement);
                        XElement falloGuidElement = new XElement("guid");
                        metaDocumentoElement.Add(falloGuidElement);
                        Guid legisGuid = IdTranslationManager.GetGuidIdForApEntity(IdentityTranslationManager.tLegislacion, idIdentLexis);
                        falloGuidElement.Value = legisGuid.ToString();
                        migraDocLogEntry.GuidSae = legisGuid;
                        migraDocLogEntry.ApId = idIdentLexis.ToString();

                        metaDocumentoElement.Add(new XElement("clip-date"));
                        XElement normaElement = new XElement("norma");
                        metaDocumentoElement.Add(normaElement);
                        normaElement.Add(new XElement("pais", StrPais));
                        normaElement.Add(new XElement("base-origen", StrBaseOrigen));
                        XElement collectionsSetElement = new XElement("collection-sets");
                        normaElement.Add(collectionsSetElement);

                        foreach (tProducto tproducto in legislacion.tProducto)
                        {
                            // Se agregan los productos                           
                            List<Guid> guidForProductoList = IdTranslationManager.GetGuidListIdForApEntity(IdentityTranslationManager.tProducto, tproducto.id_producto);

                            foreach (Guid guidForProducto in guidForProductoList)
                            {
                                XElement collectionSetElement = new XElement("collection-set");
                                collectionsSetElement.Add(collectionSetElement);
                                collectionSetElement.Value = guidForProducto.ToString();
                            }

                            //XElement collectionSetElement = new XElement("collection-set");
                            //collectionsSetElement.Add(collectionSetElement);
                            //collectionSetElement.Value = "AP" + tproducto.identificador;
                        }

                        normaElement.Add(new XElement("marcas-toc")); // TODO: ??
                        XElement emisionesElement = new XElement("emisiones");
                        normaElement.Add(emisionesElement);


                        List<EmisorOrganismo> emisionOrganismos = new List<EmisorOrganismo>();
                        // Analizo si es una conjunta
                        using (SICLANEntities ctxSiclan = new SICLANEntities())
                        {
                            var organismosConjunta = (from o in ctxSiclan.TORGANISMOCONJUNTO
                                                      where o.IDORGANISMOCONJUNTO == legislacion.id_organismo
                                                      orderby o.ORDEN
                                                      select new EmisorOrganismo()
                                                      {
                                                          OrganismoId = o.IDORGANISMO,
                                                          Orden = o.ORDEN
                                                      }).ToList();

                            emisionOrganismos.AddRange(organismosConjunta);

                            if (emisionOrganismos.Count == 0)
                            {
                                // agrego el id de organismo
                                if (!String.IsNullOrEmpty(legislacion.id_organismo))
                                {
                                    emisionOrganismos.Add(new EmisorOrganismo() { OrganismoId = legislacion.id_organismo.ToString(), Orden = 1 });
                                }
                            }
                        }

                        List<tLegislacionNorma> legislacionNormaList = ctxPeOnline.tLegislacionNorma.Where(ln => ln.id_legislacion == legislacion.id_legislacion).ToList();

                        // Registro en el log si hay diferencia
                        if (legislacionNormaList.Count != emisionOrganismos.Count)
                        {
                            MigraDocLog migraDocLogEntryOrg = new MigraDocLog();
                            migraDocLogEntryOrg.NombreArchivoGenerado = nombreDocumento;
                            migraDocLogEntryOrg.ApNombreTabla = IdentityTranslationManager.tLegislacionPartes;
                            migraDocLogEntryOrg.Excepcion = false;
                            migraDocLogEntryOrg.ApId = legislacion.idIdentLexis.Value.ToString();
                            migraDocLogEntryOrg.GuidSae = legisGuid;
                            migraDocLogEntryOrg.Mensaje = "Diferencia entre la cantidad torganismos y legislacionNorma";
                            ctxPeOnline.MigraDocLog.AddObject(migraDocLogEntryOrg);
                            ctxPeOnline.SaveChanges();
                        }

                        foreach (tLegislacionNorma legisNorma in legislacionNormaList)
                        {
                            EmisorOrganismo emisionOrganismo = emisionOrganismos.Where(e => e.Orden == (legisNorma.orden + 1)).SingleOrDefault();

                            XElement emisionElement = new XElement("emision");
                            emisionesElement.Add(emisionElement);

                            // Id de SAE según mapeo y "Lógica de Emisor/Nro. de Norma"
                            XElement emisorIdElement = new XElement("emisor-id");
                            emisionElement.Add(emisorIdElement);
                            if (emisionOrganismo != null)
                            {
                                string organismoId = emisionOrganismo.OrganismoId + "-" + legislacion.jurisdiccion;
                                emisorIdElement.Value = IdTranslationManager.GetStringIdForApEntity(IdentityTranslationManager.tOrganismo, organismoId); // TODO: el id de organismo mapeado de siclan.torganismos (uno por cada uno del conjunto de torganismo conjunto)
                            }

                            // Id de SAE según mapeo de Tipos de Norma y "Lógica de Tipos de Norma" 
                            XElement tipoDeNormaIdElement = new XElement("tipo-de-norma-id");
                            emisionElement.Add(tipoDeNormaIdElement);
                            string tipoDeNorma = legislacion.norma;
                            if (String.IsNullOrEmpty(legislacion.extra))
                            {
                                legislacion.extra = string.Empty;
                            }
                            else
                            {
                                tipoDeNorma += "E" + legislacion.extra;
                            }

                            tipoDeNormaIdElement.Value = IdTranslationManager.GetStringIdForApEntity(IdentityTranslationManager.tiposNorma, tipoDeNorma);

                            emisionElement.Add(new XElement("nro-de-norma", legisNorma.Norma));
                            emisionElement.Add(new XElement("orden", legisNorma.orden + 1));
                        }

                        normaElement.Add(new XElement("guid-nodo-norma")); //No informar                       

                        XElement fechaCargaElement = new XElement("fecha-carga");
                        normaElement.Add(fechaCargaElement);
                        fechaCargaElement.Value = legislacion.procdate.ToStringSAE();

                        XElement fechaPublicacionElement = new XElement("fecha-publicacion");
                        normaElement.Add(fechaPublicacionElement);
                        if (legislacion.fecha_pub.HasValue)
                        {
                            fechaPublicacionElement.Value = legislacion.fecha_pub.Value.ToStringSAE();
                        }

                        XElement fechaSancionElement = new XElement("fecha-sancion");
                        normaElement.Add(fechaSancionElement);
                        fechaSancionElement.Value = legislacion.fecha_sancion.ToStringSAE();

                        XElement fechaPromulgacionElement = new XElement("fecha-promulgacion");
                        normaElement.Add(fechaPromulgacionElement);
                        fechaPromulgacionElement.Value = legislacion.fecha_prom.ToStringSAE();

                        XElement fechaUltimaModificacionElement = new XElement("fecha-ultima-modificacion");
                        normaElement.Add(fechaUltimaModificacionElement);
                        fechaUltimaModificacionElement.Value = legislacion.fecha_act.ToStringSAE();

                        normaElement.Add(new XElement("fecha-vigencia-inicial")); //No informar
                        normaElement.Add(new XElement("guid-norma-generadora")); //No informar
                        normaElement.Add(new XElement("antecedentes-parlamentarios")); //No informar

                        XElement jurisdiccionIdElement = new XElement("jurisdiccion-id");
                        normaElement.Add(jurisdiccionIdElement);
                        jurisdiccionIdElement.Value = legislacion.jurisdiccion;//IdTranslationManager.GetStringIdForApEntity(IdentityTranslationManager.jurisdiccion, legislacion.jurisdiccion); // Id numérico que surge del mapeo de la sigla de AP de tLegislacion.jurisdiccion con el Id de SAE 

                        // No informar
                        XElement municipioElement = new XElement("municipio");
                        normaElement.Add(municipioElement);
                        municipioElement.Add(new XElement("area-geografica"));

                        // No informar
                        normaElement.Add(new XElement("modificado-por"));
                        normaElement.Add(new XElement("notas-especiales"));
                        normaElement.Add(new XElement("notas-historia"));
                        normaElement.Add(new XElement("notas-vigencia"));
                        normaElement.Add(new XElement("notas-internas"));

                        XElement publicacionElement = new XElement("publicacion");
                        normaElement.Add(publicacionElement);
                        if (legislacion.fecha_pub.HasValue)
                        {
                            publicacionElement.Value = "BOLETIN OFICIAL";
                        }
                        else
                        {
                            publicacionElement.Value = "COPIA OFICIAL";
                        }

                        // No informar
                        normaElement.Add(new XElement("tc-norma"));

                        XElement aparicionesElement = new XElement("apariciones");
                        metaDocumentoElement.Add(aparicionesElement);

                        using (SICLANEntities ctxSiclan = new SICLANEntities())
                        {

                            var tDatosTomoList = (from norma in ctxSiclan.TNORMAS
                                                  join datosTomo in ctxSiclan.TDATOSTOMO on norma.CUN equals datosTomo.CUN
                                                  where norma.CunOnline == legislacion.tIdentLexis.IdentLexis
                                                  select datosTomo).ToList();

                            foreach (var datosTomo in tDatosTomoList)
                            {
                                XElement aparicionElement = new XElement("aparicion");
                                aparicionesElement.Add(aparicionElement);

                                XElement colleccionElement = new XElement("coleccion"); // No informar
                                aparicionElement.Add(colleccionElement);

                                XElement tomoElemnt = new XElement("tomo"); //<!--Adrián: Informar el tomo de la tabla de SICLAN: TTOMO (campo DSTOMO)-->
                                aparicionElement.Add(tomoElemnt);
                                if (datosTomo.TTOMO != null)
                                {
                                    tomoElemnt.Value = datosTomo.TTOMO.DSTOMO;
                                }

                                XElement paginaElemnt = new XElement("pagina"); //	<!--Adrián: Informar de la tabla TDATOSTOMO de SICLAN, extraer del campo CITA el último número, en el ejemplo "2004-C-4072", el número 4072. -->
                                aparicionElement.Add(paginaElemnt);
                                if (!string.IsNullOrEmpty(datosTomo.CITA))
                                {
                                    string[] citasStr = datosTomo.CITA.Split('-');
                                    paginaElemnt.Value = citasStr.LastOrDefault();
                                }
                            }
                        }

                        XElement citasElement = new XElement("citas");
                        metaDocumentoElement.Add(citasElement);
                        // Foreach
                        XElement citaElement = new XElement("cita");
                        citaElement.Add(new XAttribute("tipo", "online"), new XAttribute("vigente", "true"));
                        citaElement.Value = legislacion.tIdentLexis.IdentLexis; //CUN/Cita de AP
                        citasElement.Add(citaElement);
                        // Fin del For-each

                        XElement novusElement = new XElement("novus", new XElement("id"), new XElement("accion", "ENVIAR"), new XElement("fecha-de-modificacion"));
                        metaDocumentoElement.Add(novusElement);


                        XElement derechoTrabajoElement = new XElement("derecho-trabajo");
                        metaDocumentoElement.Add(derechoTrabajoElement);
                        derechoTrabajoElement.Add(new XElement("apariciones"));
                        derechoTrabajoElement.Add(new XElement("bibliografia-destacada"));
                        derechoTrabajoElement.Add(new XElement("boletin"));
                        XElement citasLegalesElement = new XElement("citas-legales");
                        derechoTrabajoElement.Add(citasLegalesElement);
                        string stringCitasLegales = "" + legislacion.citadas;
                        if (stringCitasLegales != "")
                        {
                            citasLegalesElement.Add(new XCData(ProcesarCuerpo(ctxPeOnline, legisGuid, legislacion.idIdentLexis.Value, stringCitasLegales))); // Averiguar de donde obtener este valor. Va con CDATA
                        }

                        derechoTrabajoElement.Add(new XElement("comentario-anales"));
                        derechoTrabajoElement.Add(new XElement("comentario-fiscal"));
                        derechoTrabajoElement.Add(new XElement("escalas"));
                        XElement fechaEmisionElement = new XElement("fecha-emision");
                        derechoTrabajoElement.Add(fechaEmisionElement);
                        fechaEmisionElement.Value = ""; // obtener la fecha de emision de la tabla tLegislacion
                        XElement fechaHomologacionElement = new XElement("fecha-homologacion");
                        derechoTrabajoElement.Add(fechaHomologacionElement);
                        fechaHomologacionElement.Value = legislacion.fecha_hom.ToStringSAE();
                        derechoTrabajoElement.Add(new XElement("fecha-newsletter-dt"));
                        derechoTrabajoElement.Add(new XElement("fecha-newsletter-fiscal"));
                        XElement fechaVencimientoElement = new XElement("fecha-vencimiento");
                        derechoTrabajoElement.Add(fechaVencimientoElement);
                        fechaVencimientoElement.Value = ""; // Averiguar de donde obtener este valor
                        derechoTrabajoElement.Add(new XElement("fe-de-erratas"));

                        XElement normaHomologatoriaElement = new XElement("norma-homologatoria");
                        derechoTrabajoElement.Add(normaHomologatoriaElement);
                        string stringNormaLegislacion = "" + legislacion.norma;
                        string stringCclLegislacion = "" + legislacion.ccl;
                        if (stringNormaLegislacion == "CONVENCIÓN COLECTIVA DE TRABAJO" && stringCclLegislacion != "")
                        {
                            normaHomologatoriaElement.Add(new XCData(ProcesarCuerpo(ctxPeOnline, legisGuid, legislacion.idIdentLexis.Value, legislacion.ccl)));
                        }

                        XElement gratificacionesElement = new XElement("gratificaciones");
                        derechoTrabajoElement.Add(gratificacionesElement);
                        gratificacionesElement.Value = ""; // Averiguar de donde obtener este valor. Va con CDATA
                        derechoTrabajoElement.Add(new XElement("acuerdos-empresas"));
                        XElement normasComplementariasElement = new XElement("normas-complementarias");
                        derechoTrabajoElement.Add(normasComplementariasElement);
                        normasComplementariasElement.Value = ""; // Averiguar de donde obtener este valor. Va con CDATA
                        derechoTrabajoElement.Add(new XElement("acuerdos-subactividad"));
                        derechoTrabajoElement.Add(new XElement("observaciones"));
                        derechoTrabajoElement.Add(new XElement("notas-vigencia-convenio"));
                        derechoTrabajoElement.Add(new XElement("papel", "B")); ////  <papel>B</papel> Averiguar de donde obtener este valor.
                        XElement parteEmpresarialElement = new XElement("parte-empresarial");
                        derechoTrabajoElement.Add(parteEmpresarialElement);
                        XElement parteSindicalElement = new XElement("parte-sindical");
                        derechoTrabajoElement.Add(parteSindicalElement);

                        tLegislacionCcp_Partes tLegislacionCcp_Partes = ctxPeOnline.tLegislacionCcp_Partes.Where(ccp => ccp.id_legislacion == legislacion.id_legislacion).SingleOrDefault();
                        if (tLegislacionCcp_Partes != null)
                        {

                            if (!string.IsNullOrEmpty(tLegislacionCcp_Partes.parte_empresaria))
                            {
                                parteEmpresarialElement.Value = tLegislacionCcp_Partes.parte_empresaria;
                            }

                            if (!string.IsNullOrEmpty(tLegislacionCcp_Partes.parte_sindical))
                            {
                                parteSindicalElement.Value = tLegislacionCcp_Partes.parte_sindical;
                            }
                        }

                        derechoTrabajoElement.Add(new XElement("rama-actividad"));
                        derechoTrabajoElement.Add(new XElement("subactividad"));
                        derechoTrabajoElement.Add(new XElement("topes"));

                        XElement convenioTipoAlcanceElement = new XElement("convenio-tipo-alcance");
                        derechoTrabajoElement.Add(convenioTipoAlcanceElement);
                        string stringConvenioTipoAlcance = "";
                        if (legislacion.cct == "<Parrafo>Convenio colectivo de actividad</Parrafo>" || legislacion.cct == "<Parrafo>@CCT = Convenio colectivo de actividad</Parrafo>")
                        {
                            stringConvenioTipoAlcance = "Actividad";
                        }

                        if (legislacion.cct == "<Parrafo>Convenio colectivo de empresa</Parrafo>" || legislacion.cct == "<Parrafo>@CCT = Convenio colectivo de empresa</Parrafo>")
                        {
                            stringConvenioTipoAlcance = "Empresa";
                        }

                        if (legislacion.cct == "<Parrafo>Convenio colectivo regional</Parrafo>")
                        {
                            stringConvenioTipoAlcance = "Regional";
                        }

                        convenioTipoAlcanceElement.Value = stringConvenioTipoAlcance;
                        XElement fechaCelebracionTwoElement = new XElement("fecha-celebracion");
                        derechoTrabajoElement.Add(fechaCelebracionTwoElement);
                        XElement lugarCelebracionTwoElement = new XElement("lugar-celebracion");
                        derechoTrabajoElement.Add(lugarCelebracionTwoElement);
                        XElement ambitoAplicacionElement = new XElement("ambito-aplicacion");
                        derechoTrabajoElement.Add(ambitoAplicacionElement);

                        if (legislacion.norma == "CONVENCIÓN COLECTIVA DE TRABAJO")
                        {
                            if (!string.IsNullOrEmpty(legislacion.fecha_cel.ToStringSAE()))
                            {
                                fechaCelebracionTwoElement.Value = legislacion.fecha_cel.ToStringSAE();
                            }
                            if (!string.IsNullOrEmpty(legislacion.cclu))
                            {
                                lugarCelebracionTwoElement.Value = legislacion.cclu;
                            }
                            if (!string.IsNullOrEmpty(legislacion.cca))
                            {
                                ambitoAplicacionElement.Value = legislacion.cca;
                            }
                        }

                        metaDocumentoElement.Add(new XElement("tipo-contenido", "Texto Completo"));

                        XElement sumarioElement = new XElement("sumario");
                        metaDocumentoElement.Add(sumarioElement);

                        // Busco el subtitulo en peonline
                        StringBuilder sumarioBuilder = new StringBuilder();
                        List<string> sumarioTituloList = new List<string>();
                        foreach (var taxonomia in legislacion.tLegislacionXTaxonomia)
                        {
                            foreach (var tituloXTax in taxonomia.tLegislacionTitulo)
                            {
                                if (!String.IsNullOrEmpty(tituloXTax.Titulo))
                                {
                                    string titulo = ProcesarCuerpo(ctxPeOnline, legisGuid, legislacion.idIdentLexis.Value, tituloXTax.Titulo);
                                    //string titulo = HtmlDecode(tituloXTax.Titulo);
                                    if (sumarioTituloList.Where(t => t == titulo).Count() == 0)
                                    {
                                        sumarioTituloList.Add(titulo);
                                        sumarioBuilder.AppendLine(titulo);
                                    }
                                }
                            }
                        }

                        string textSumarioPeOnline = sumarioBuilder.ToString();
                        if (!String.IsNullOrEmpty(textSumarioPeOnline))
                        {
                            sumarioElement.Add(new XCData(textSumarioPeOnline));
                        }
                        else
                        {
                            sumarioTituloList.Clear();
                            sumarioBuilder = new StringBuilder();
                            // Si no está en peonline, lo busco en siclan
                            using (SICLANEntities ctxSiclan = new SICLANEntities())
                            {
                                var tSubtituloList = (from norma in ctxSiclan.TNORMAS
                                                      join subtitulo in ctxSiclan.TSUBTITULOSXNORMA on norma.CUN equals subtitulo.CUN
                                                      where norma.CunOnline == legislacion.tIdentLexis.IdentLexis
                                                      select subtitulo).ToList();

                                if (tSubtituloList != null)
                                {
                                    foreach (var tSubtitulo in tSubtituloList)
                                    {
                                        string titulo = HtmlDecode(tSubtitulo.DSSUBTITULO);
                                        if (sumarioTituloList.Where(t => t == titulo).Count() == 0)
                                        {
                                            sumarioTituloList.Add(titulo);
                                            sumarioBuilder.AppendLine(titulo);
                                        }
                                    }
                                    //sumarioElement.Value = tSubtituloList.DSSUBTITULO;
                                    sumarioElement.Value = sumarioBuilder.ToString();

                                }
                            }
                        }

                        metaDocumentoElement.Add(new XElement("descripcion"));
                        XElement fechaVigenciaFinalElement = new XElement("fecha-vigencia-final");
                        metaDocumentoElement.Add(fechaVigenciaFinalElement);
                        fechaVigenciaFinalElement.Value = ""; // Averiguar de donde obtener este valor.
                        metaDocumentoElement.Add(new XElement("fecha-vigencia-inicial"));
                        XElement fechaOrdenamientoElement = new XElement("fecha-ordenamiento");
                        metaDocumentoElement.Add(fechaOrdenamientoElement);

                        using (SICLANEntities ctxSiclan = new SICLANEntities())
                        {
                            var fechaordenada = (from relaciones in ctxSiclan.TRELACIONESXNORMA
                                                 join estructuranxn in ctxSiclan.TESTRUCTURANORMAXNORMA on relaciones.IDESTRUCTURAPRIMARIA equals estructuranxn.IDESTRUCTURANORMAXNORMA
                                                 join normas in ctxSiclan.TNORMAS on estructuranxn.CUN equals normas.CUN
                                                 join fechas in ctxSiclan.TFECHASXNORMA on estructuranxn.CUN equals fechas.CUN
                                                 where relaciones.IDTIPORELACION == 37
                                                 && fechas.IDTIPOFECHA == 5
                                                 && normas.CunOnline == legislacion.tIdentLexis.IdentLexis
                                                 select fechas).SingleOrDefault();

                            if (fechaordenada != null)
                            {
                                if (!string.IsNullOrEmpty(fechaordenada.VALUE.ToStringSAE()))
                                {
                                    fechaOrdenamientoElement.Value = fechaordenada.VALUE.ToStringSAE();
                                }
                            }
                        }

                        XElement ordenInternoElement = new XElement("orden-interno");
                        metaDocumentoElement.Add(ordenInternoElement);
                        XElement versionAnteriorElement = new XElement("version-anterior");
                        metaDocumentoElement.Add(versionAnteriorElement);
                        versionAnteriorElement.Value = ""; // Averiguar de donde se obtiene este valor
                        metaDocumentoElement.Add(new XElement("version-posterior"));
                        XElement vocesElement = new XElement("voces");
                        metaDocumentoElement.Add(vocesElement);

                        List<MigraVoz> vocesFiltradasPorArbolDeVoces = (from l in legislacion.tLegislacionXTaxonomia
                                                                        orderby l.nivel, l.nro
                                                                        select new MigraVoz
                                                                        {
                                                                            Nombre = HtmlDecode(l.tTaxonomia.Nombre),
                                                                            IdTaxonomia = l.idTaxonomia,
                                                                            Nivel = l.nivel,
                                                                            Numero = l.nro,
                                                                            EsVozDelArbolDeVoces = true
                                                                        }).ToList();

                        foreach (MigraVoz migraVoz in vocesFiltradasPorArbolDeVoces)
                        {
                            XElement vozElement = new XElement("voz");
                            vozElement.Add(new XAttribute("numero", migraVoz.Numero));
                            vozElement.Add(new XAttribute("nivel", migraVoz.Nivel));
                            vozElement.Add(new XAttribute("id_taxonomia", migraVoz.IdTaxonomia));
                            vozElement.Add(new XAttribute("vozArbol", migraVoz.EsVozDelArbolDeVoces));
                            vozElement.Value = migraVoz.Nombre;
                            vocesElement.Add(vozElement);
                        }

                        metaDocumentoElement.Add(new XElement("collection-set-elemento"));
                        metaDocumentoElement.Add(new XElement("regimenes"));
                        metaDocumentoElement.Add(new XElement("productos-digitales"));
                        metaDocumentoElement.Add(new XElement("tema-elemento"));
                        metaDocumentoElement.Add(new XElement("estado-texto", "Con Texto"));
                        XElement normaActualizadaElement = new XElement("norma-actualizada");
                        metaDocumentoElement.Add(normaActualizadaElement);
                        if (legislacion.act.Value)
                        {
                            normaActualizadaElement.Value = "S";
                        }
                        else
                        {
                            normaActualizadaElement.Value = "N";
                        }

                        XElement fechaModificacionEditorialElement = new XElement("fecha-modificacion-editorial");
                        metaDocumentoElement.Add(fechaModificacionEditorialElement);
                        fechaModificacionEditorialElement.Value = legislacion.fecha_act.ToStringSAE();
                        metaDocumentoElement.Add(new XElement("publicaciones-news"));
                        metaDocumentoElement.Add(new XElement("relaciones-documento"));
                        XElement contDocumentoElement = new XElement("cont-legislacion");
                        documentoElement.Add(contDocumentoElement);
                        XElement notasHistoriaElement = new XElement("notas-historia");
                        contDocumentoElement.Add(notasHistoriaElement);
                        XElement guidNotasHistoriaElement = new XElement("guid");
                        notasHistoriaElement.Add(guidNotasHistoriaElement);
                        XElement textoRefNotasHistoriasElement = new XElement("texto-ref");
                        notasHistoriaElement.Add(textoRefNotasHistoriasElement);
                        if (!String.IsNullOrEmpty(legislacion.asteriscos) && legislacion.asteriscos != "(*)") //!string.IsNullOrEmpty(legislacion.oto) && legislacion.oto != "(*)")
                        {
                            //guidNotasHistoriaElement.Value = IdTranslationManager.GetStringIdForApEntity(IdentityTranslationManager.tLegislacion, legislacion.asteriscos);
                            textoRefNotasHistoriasElement.Add(new XCData(legislacion.asteriscos));
                        }
                        else
                        {
                            if (!string.IsNullOrEmpty(legislacion.ccl) && legislacion.norma != "CONVENCIÓN COLECTIVA DE TRABAJO")
                            {
                                //guidNotasHistoriaElement.Value = IdTranslationManager.GetStringIdForApEntity(IdentityTranslationManager.tLegislacion, legislacion.ccl);
                                textoRefNotasHistoriasElement.Add(new XCData(ProcesarCuerpo(ctxPeOnline, legisGuid, legislacion.idIdentLexis.Value, legislacion.ccl)));
                            }
                        }

                        contDocumentoElement.Add(new XElement("notas-vigencia"));

                        XElement notasEspecialesElement = new XElement("notas-especiales");
                        contDocumentoElement.Add(notasEspecialesElement);

                        XElement notasAlPieElement = new XElement("notas-al-pie");
                        contDocumentoElement.Add(notasAlPieElement);

                        XElement anexosElement = new XElement("anexos");
                        contDocumentoElement.Add(anexosElement);

                        contDocumentoElement.Add(new XElement("comentarios"));
                        contDocumentoElement.Add(new XElement("comentarios-esenciales"));
                        contDocumentoElement.Add(new XElement("idioma", new XAttribute("ranking", "")));

                        XElement textoLegislacionElement = new XElement("texto-legislacion");
                        contDocumentoElement.Add(textoLegislacionElement);

                        StringBuilder textoLegislacionCompletoParaLinksBuilder = new StringBuilder();

                        // vistos
                        textoLegislacionCompletoParaLinksBuilder.Append("<visto>");
                        textoLegislacionCompletoParaLinksBuilder.Append(legislacion.visto);
                        textoLegislacionCompletoParaLinksBuilder.Append("</visto>");

                        // considerando
                        textoLegislacionCompletoParaLinksBuilder.Append("<considerando>");
                        textoLegislacionCompletoParaLinksBuilder.Append(legislacion.intro_considerando);
                        textoLegislacionCompletoParaLinksBuilder.Append(legislacion.considerando);
                        textoLegislacionCompletoParaLinksBuilder.Append("</considerando>");

                        // Sancionado
                        textoLegislacionCompletoParaLinksBuilder.Append("<sancionado>");
                        textoLegislacionCompletoParaLinksBuilder.Append(legislacion.sancionado);
                        textoLegislacionCompletoParaLinksBuilder.Append("</sancionado>");

                        textoLegislacionCompletoParaLinksBuilder.Append("<notascabecera>");
                        int cantNotasCabecera = 0;
                        foreach (tLegislacionNotasCabecera notaCabecera in legislacion.tLegislacionNotasCabecera)
                        {
                            textoLegislacionCompletoParaLinksBuilder.Append("<notacabecera>");
                            textoLegislacionCompletoParaLinksBuilder.Append(notaCabecera.nota);
                            textoLegislacionCompletoParaLinksBuilder.Append("</notacabecera>");
                            cantNotasCabecera++;
                        }

                        textoLegislacionCompletoParaLinksBuilder.Append("</notascabecera>");

                        textoLegislacionCompletoParaLinksBuilder.Append("<textos>");
                        int itextoCantidad = 0;
                        foreach (tLegislacionPartes parte in legislacion.tLegislacionPartes)
                        {
                            foreach (tLegislacionCuerpo cuerpo in parte.tLegislacionCuerpo)
                            {
                                //textoLegislacionBuilder.Append(string.Format("<texto orden=\"{0}\">", parte.orden));
                                textoLegislacionCompletoParaLinksBuilder.Append("<texto>");

                                // Puede ser que nivel legis

                                textoLegislacionCompletoParaLinksBuilder.Append(cuerpo.contenido);
                                if (AppendNivelLegis(cuerpo.contenido))
                                {
                                    textoLegislacionCompletoParaLinksBuilder.Append("</NivelLegis>");
                                }

                                textoLegislacionCompletoParaLinksBuilder.Append("</texto>");
                                itextoCantidad++;
                            }
                        }

                        textoLegislacionCompletoParaLinksBuilder.Append("</textos>");

                        textoLegislacionCompletoParaLinksBuilder.Append("<firma>");
                        textoLegislacionCompletoParaLinksBuilder.Append(legislacion.firma);
                        textoLegislacionCompletoParaLinksBuilder.Append("</firma>");

                        textoLegislacionCompletoParaLinksBuilder.Append("<notas>");
                        int inotasCant2 = 0;
                        foreach (tLegislacionNotas nota in legislacion.tLegislacionNotas)
                        {
                            textoLegislacionCompletoParaLinksBuilder.Append("<nota>");
                            textoLegislacionCompletoParaLinksBuilder.Append(nota.nota);
                            textoLegislacionCompletoParaLinksBuilder.Append("</nota>");
                            inotasCant2++;
                        }

                        textoLegislacionCompletoParaLinksBuilder.Append("</notas>");

                        textoLegislacionCompletoParaLinksBuilder.Append("<anexos>");
                        int anexosCant = 0;
                        foreach (tLegislacionPartes parte in legislacion.tLegislacionPartes)
                        {
                            foreach (tLegislacionAnexo anexo in parte.tLegislacionAnexo)
                            {
                                //textoLegislacionBuilder.Append(string.Format("<anexo orden=\"{0}\" nroanexo=\"{1}\">", anexo.orden, anexo.nroanexo));
                                textoLegislacionCompletoParaLinksBuilder.Append("<anexo>");

                                textoLegislacionCompletoParaLinksBuilder.Append(anexo.contenido);

                                textoLegislacionCompletoParaLinksBuilder.Append("</anexo>");
                                anexosCant++;
                            }
                        }

                        textoLegislacionCompletoParaLinksBuilder.Append("</anexos>");

                        string documentText = ProcesarCuerpo(ctxPeOnline, legisGuid, legislacion.idIdentLexis.Value, textoLegislacionCompletoParaLinksBuilder.ToString());

                        //textoLegislacionElement.Add(new XCData(documentText));

                        StringBuilder textoBuilder = new StringBuilder();

                        // Vistos
                        //XElement vistoElement = new XElement("visto");
                        //textoLegislacionElement.Add(vistoElement);
                        //vistoElement.Add(new XCData(GetTextBetweenTags(documentText, "<visto>", "</visto>")));
                        textoBuilder.AppendLine(ProcesarParrafos(GetTextBetweenTags(documentText, "<visto>", "</visto>"), "VISTO"));

                        // Considerando
                        //XElement considerandoElement = new XElement("considerando");
                        //textoLegislacionElement.Add(considerandoElement);
                        //considerandoElement.Add(new XCData(GetTextBetweenTags(documentText, "<considerando>", "</considerando>")));
                        textoBuilder.AppendLine(ProcesarParrafos(GetTextBetweenTags(documentText, "<considerando>", "</considerando>"), "CONSIDERANDO"));

                        // Sancionado
                        //XElement sancionadoElement = new XElement("sancionado");
                        //textoLegislacionElement.Add(sancionadoElement);
                        //sancionadoElement.Add(new XCData(GetTextBetweenTags(documentText, "<sancionado>", "</sancionado>")));
                        textoBuilder.AppendLine(ProcesarParrafos(GetTextBetweenTags(documentText, "<sancionado>", "</sancionado>"), "SANCIONADO"));

                        int indexStartTag = 0;
                        int indexEndTag = 0;

                        //XElement notascabeceraElement = new XElement("notascabecera");
                        //textoLegislacionElement.Add(notascabeceraElement);
                        StringBuilder notaCabeceraBuilder = new StringBuilder();
                        for (int inota = 0; inota < cantNotasCabecera; inota++)
                        {
                            //XElement notacabeceraElement = new XElement("notascabecera");
                            //notasEspecialesElement.Add(notacabeceraElement);                            
                            string startTag = "<notacabecera>";
                            indexStartTag = documentText.IndexOf("<notacabecera>", indexStartTag);
                            indexEndTag = documentText.IndexOf("</notacabecera>", indexStartTag);

                            //notacabeceraElement.Add(new XCData(documentText.Substring(indexStartTag + startTag.Length, indexEndTag - (indexStartTag + startTag.Length))));

                            notaCabeceraBuilder.AppendLine(documentText.Substring(indexStartTag + startTag.Length, indexEndTag - (indexStartTag + startTag.Length)));

                            indexStartTag = indexEndTag;
                        }

                        notasEspecialesElement.Add(new XCData(notaCabeceraBuilder.ToString()));

                        // texto
                        //XElement textosElement = new XElement("textos");
                        //textoLegislacionElement.Add(textosElement);

                        for (int itexto = 0; itexto < itextoCantidad; itexto++)
                        {
                            //XElement textoElement = new XElement("texto");
                            //textosElement.Add(textoElement);
                            string startTag = "<texto>";
                            indexStartTag = documentText.IndexOf("<texto>", indexStartTag);
                            indexEndTag = documentText.IndexOf("</texto>", indexStartTag);

                            //textoElement.Add(new XCData(documentText.Substring(indexStartTag + startTag.Length, indexEndTag - (indexStartTag + startTag.Length))));

                            textoBuilder.AppendLine(ProcesarParrafos(documentText.Substring(indexStartTag + startTag.Length, indexEndTag - (indexStartTag + startTag.Length)), "TEXTO"));

                            indexStartTag = indexEndTag;
                        }

                        // Firma
                        //XElement firmaElement = new XElement("firma");
                        //textoLegislacionElement.Add(firmaElement);
                        //firmaElement.Add(new XCData(GetTextBetweenTags(documentText, "<firma>", "</firma>")));
                        textoBuilder.AppendLine(ProcesarParrafos(GetTextBetweenTags(documentText, "<firma>", "</firma>"), "FIRMA"));


                        //XElement notasElement = new XElement("notas");
                        //textoLegislacionElement.Add(notasElement);
                        StringBuilder notasBuilder = new StringBuilder();
                        for (int inota = 0; inota < inotasCant2; inota++)
                        {
                            //XElement notaElement = new XElement("nota");
                            //notasElement.Add(notaElement);
                            string startTag = "<nota>";
                            indexStartTag = documentText.IndexOf("<nota>", indexStartTag);
                            indexEndTag = documentText.IndexOf("</nota>", indexStartTag);

                            //notaElement.Add(new XCData(documentText.Substring(indexStartTag + startTag.Length, indexEndTag - (indexStartTag + startTag.Length))));

                            notasBuilder.AppendLine(documentText.Substring(indexStartTag + startTag.Length, indexEndTag - (indexStartTag + startTag.Length)));
                            indexStartTag = indexEndTag;
                        }

                        notasAlPieElement.Add(new XCData(notasBuilder.ToString()));

                        //XElement anexosElement = new XElement("anexos");
                        //textoLegislacionElement.Add(anexosElement);
                        StringBuilder anexoBuilder = new StringBuilder();
                        for (int ianexo = 0; ianexo < anexosCant; ianexo++)
                        {
                            //XElement notaElement = new XElement("anexo");
                            //anexosElement.Add(notaElement);
                            string startTag = "<anexo>";
                            indexStartTag = documentText.IndexOf("<anexo>", indexStartTag);
                            indexEndTag = documentText.IndexOf("</anexo>", indexStartTag);

                            //notaElement.Add(new XCData(documentText.Substring(indexStartTag + startTag.Length, indexEndTag - (indexStartTag + startTag.Length))));

                            anexoBuilder.AppendLine(documentText.Substring(indexStartTag + startTag.Length, indexEndTag - (indexStartTag + startTag.Length)));

                            indexStartTag = indexEndTag;
                        }

                        anexosElement.Add(new XCData(anexoBuilder.ToString()));

                        textoLegislacionElement.Add(new XCData(textoBuilder.ToString()));

                        //Armar el texto de AP con los siguientes campos, en este orden y aplicando estilos para que quede diferenciada cada parte del texto:
                        //- Visto
                        //- Considerando
                        //- Sancionado
                        //- Notas Cabecera
                        //- TEXTO
                        //- Firma
                        //- Notas
                        //- Anexos
                        //tLegislacion.visto + " " + tLegislacion.intro_considerando + " " + tLegislacion.considerando + " " + tLegislacion.sancionado + 
                        //tLegislacionNotasCabecera + " TEXTO: " + (tLegislacionPartes -> tLegislacionCuerpo) +  
                        //tLegislacion.firma + 
                        //tLegislacionNotas + 
                        //ANEXOS (tLegislacionPartes -> tLegislacionAnexo)
                        //IMPORTANTE: Cada parte del texto debe quedar identificado con un estilo particular.

                        string path = Path.Combine(this.OutputPath, "Legislacion");
                        if (!Directory.Exists(path))
                        {
                            Directory.CreateDirectory(path);
                        }
                        
                        legisDocument.Save(Path.Combine(path, nombreDocumento));                      
                    }
                    catch (Exception ex)
                    {
                        migraDocLogEntry.Excepcion = true;
                        string message = GetExceptionMessage(ex);
                        string stack = GetExceptionStackTrace(ex);
                        migraDocLogEntry.Mensaje = message + stack;
                        throw;
                    }
                    finally
                    {
                        ctxPeOnline.MigraDocLog.AddObject(migraDocLogEntry);
                        ctxPeOnline.SaveChanges();
                    }

                }
            }
        }

        private string ProcesarParrafos(string text, string estiloParaParrafo)
        {
            if (String.IsNullOrEmpty(text))
            {
                return string.Empty;
            }
            else
            {
                if (text.Contains("NULL"))
                {
                    text = text.Replace("NULL", string.Empty);
                }

                text = "<root>" + text + "</root>";
                using (StringReader strReader = new StringReader(text))
                {
                    XDocument xCuerpoFallo = XDocument.Load(strReader);
                    List<XElement> parrafosElement = (from node in xCuerpoFallo.Descendants()
                                                      where node.Name == "Parrafo"
                                                      select node).ToList();

                    if (parrafosElement.Count() == 0)
                    {
                        text = text.Replace("<root>", string.Empty);
                        text = text.Replace("</root>", string.Empty);

                        return string.Format("<Parrafo estilo=\"{1}\" >{0}</Parrafo>", text, estiloParaParrafo);
                    }
                    else
                    {

                        foreach (XElement parrafoElement in parrafosElement)
                        {
                            XAttribute estiloXAttribute = parrafoElement.Attribute("estilo");
                            if (estiloXAttribute == null)
                            {
                                estiloXAttribute = new XAttribute("estilo", string.Empty);
                                parrafoElement.Add(estiloXAttribute);
                            }

                            if (string.IsNullOrEmpty(estiloXAttribute.Value))
                            {
                                estiloXAttribute.Value = estiloParaParrafo;
                            }
                            else
                            {
                                estiloXAttribute.Value += " " + estiloParaParrafo;
                            }
                        }


                        string textoStr = xCuerpoFallo.ToString();
                        textoStr = textoStr.Remove(0, 6);
                        if (textoStr[0] == '\r' && textoStr[1] == '\n')
                        {
                            textoStr = textoStr.Remove(0, 2);
                        }

                        textoStr = textoStr.Remove(textoStr.Length - 7, 7);

                        strReader.Close();

                        return textoStr;
                    }
                }
            }
        }

        private bool AppendNivelLegis(string cuerpo)
        {

            // Cuento los tags de nivel legis que abren y lso que cierran
            int indexOpen = 0;
            int indexClose = 0;
            int indexOpenCount = 0;
            int indexCloseCount = 0;

            while (indexOpen != -1)
            {
                indexOpen = cuerpo.IndexOf("<NivelLegis", indexOpen);
                if (indexOpen != -1)
                {
                    indexOpenCount++;
                    indexOpen++;

                    indexClose = cuerpo.IndexOf("</NivelLegis", indexOpen);
                    if (indexClose != -1)
                    {
                        indexCloseCount++;
                        indexOpen = indexClose + 1;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            return indexOpenCount != indexCloseCount;

        }

        public static List<CitaAp> citasAP = new List<CitaAp>()
        {
            new CitaAp(){ Starts = "BA", TipoDeCita = CitaAp.baseoficial },
            new CitaAp(){ Starts = "Fallos", TipoDeCita = CitaAp.fallocorte },
            new CitaAp(){ Starts = "CHU", TipoDeCita = CitaAp.baseoficial },
            new CitaAp(){ Starts = "SE", TipoDeCita = CitaAp.baseoficial },
            new CitaAp(){ Starts = "MZA", TipoDeCita = CitaAp.baseoficial },
            new CitaAp(){ Starts = "NQ", TipoDeCita = CitaAp.baseoficial },
            new CitaAp(){ Starts = "JO", TipoDeCita = CitaAp.baseoficial },
            new CitaAp(){ Starts = "Dict", TipoDeCita = CitaAp.dictamen },
      
            new CitaAp(){ Starts = "JA", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "RDLSS", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "RDCO", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "LNL", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "LNBA", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "LNC", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "APBA", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "RDFI", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "SJA", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "APC", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "RDF ", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "as", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "TO", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "RDAmb", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "RDA", TipoDeCita = CitaAp.aparicion },                       
            new CitaAp(){ Starts = "RDP", TipoDeCita = CitaAp.aparicion },
            new CitaAp(){ Starts = "AP%%BA", TipoDeCita = CitaAp.aparicion }
        };

        public static void AgregarAnalisisDeCita(XElement citasElement, System.Data.Objects.DataClasses.EntityCollection<tCita> entityCollection)
        {
            foreach (var cita in entityCollection)
            {
                List<string> publicaciones = cita.Nombre.Split(';').ToList();
                foreach (var pub in publicaciones)
                {
                    string publicacion = pub.Trim();
                    CitaAp citaAp = citasAP.Where(c => publicacion.StartsWith(c.Starts)).SingleOrDefault();
                    if (citaAp != null)
                    {
                        XElement citaElement = new XElement("cita", new XAttribute("tipo", citaAp.TipoDeCita));
                        citaElement.Value = HtmlDecode(publicacion);
                        citasElement.Add(citaElement);
                    }
                }
            }
        }
    }
}
